// 相册管理模块
class PhotoGallery {
    constructor() {
        this.photos = [];
        this.currentFilter = 'all';
        this.isLoading = false;
        console.log('PhotoGallery 构造函数被调用');
    }

    // 初始化相册
    async init() {
        console.log('=== 相册模块初始化开始 ===');
        console.log('当前环境检查:', {
            'plus对象存在': typeof plus !== 'undefined',
            'document对象存在': typeof document !== 'undefined',
            'window对象存在': typeof window !== 'undefined'
        });
        
        try {
            // 检查H5+环境
            if (typeof plus === 'undefined') {
                console.warn('H5+环境未检测到，无法加载照片');
                this.photos = [];
                this.renderPhotos();
                return;
            }
            
            // 加载真实照片数据
            await this.loadRealPhotos();
            
            // 更新顶部统计信息
            this.updateHeaderStats();
        } catch (error) {
            console.error('相册初始化失败，详细错误:', error);
            console.error('错误堆栈:', error.stack);
            this.photos = [];
            this.renderPhotos();
        }
    }

    // 加载真实照片数据
    async loadRealPhotos() {
        console.log('=== 开始加载真实照片数据 ===');
        
        // 检查plus.io对象
        console.log('检查plus.io对象:', typeof plus.io);
        console.log('检查plus.io.resolveLocalFileSystemURL方法:', typeof plus.io.resolveLocalFileSystemURL);
        
        // 使用相对路径URL
        const basePath = '_doc/PhotoFiler/';
        console.log('使用相对路径URL:', basePath);
        
        try {
            // 确保目录存在
            await this.ensureDirectoryExists(basePath);
            
            // 读取PhotoFiler目录
            const photoFilerEntries = await this.readDirectory(basePath);
            console.log('PhotoFiler目录读取结果，总条目数:', photoFilerEntries.length);
            console.log('目录内容详情:', photoFilerEntries.map(entry => entry.name));
            
            this.photos = [];
            
            // 遍历PhotoFiler目录下的所有条目
            for (const entry of photoFilerEntries) {
                if (entry.isDirectory) {
                    // 这是一个分组目录
                    console.log('发现分组目录:', entry.name);
                    const groupName = entry.name;
                    
                    // 读取分组目录下的照片
                    const groupPath = basePath + groupName + '/';
                    console.log('读取分组目录:', groupPath);
                    
                    try {
                        const groupEntries = await this.readDirectory(groupPath);
                        console.log('分组目录内容:', groupEntries.map(e => e.name));
                        
                        // 过滤出图片文件
                        const imageFiles = groupEntries.filter(entry => this.isImageFile(entry.name));
                        console.log('分组中的图片文件:', imageFiles.map(f => f.name));
                        
                        // 为每个图片文件创建照片对象
                        for (const fileEntry of imageFiles) {
                            const photoObj = await this.createPhotoObject(fileEntry, groupName);
                            this.photos.push(photoObj);
                        }
                    } catch (error) {
                        console.error('读取分组目录失败:', groupPath, error);
                    }
                } else if (entry.isFile && this.isImageFile(entry.name)) {
                    // 这是根目录下的图片文件（旧照片，没有分组）
                    console.log('发现根目录下的图片文件:', entry.name);
                    const photoObj = await this.createPhotoObject(entry, '未分组');
                    this.photos.push(photoObj);
                }
            }
            
            // 按时间倒序排列
            this.photos.sort((a, b) => b.timestamp - a.timestamp);
            
            console.log('真实照片加载完成:', this.photos.length, '张');
            console.log('照片列表:', this.photos.map(p => ({ name: p.filename, group: p.group })));
            this.renderPhotos();
        } catch (error) {
            console.error('加载真实照片失败:', error);
            this.photos = [];
            this.renderPhotos();
        }
    }

    // 确保目录存在
    ensureDirectoryExists(dirPath) {
        console.log('确保目录存在:', dirPath);
        return new Promise((resolve, reject) => {
            plus.io.resolveLocalFileSystemURL(dirPath, (entry) => {
                console.log('目录已存在:', entry);
                resolve(entry);
            }, (error) => {
                console.log('目录不存在，尝试创建:', error.message);
                // 目录不存在，尝试创建
                this.createDirectory(dirPath).then(resolve).catch(reject);
            });
        });
    }

    // 创建目录
    createDirectory(dirPath) {
        console.log('创建目录:', dirPath);
        return new Promise((resolve, reject) => {
            // 获取父目录
            const parentPath = dirPath.substring(0, dirPath.lastIndexOf('/'));
            const dirName = dirPath.substring(dirPath.lastIndexOf('/') + 1);
            
            console.log('父目录路径:', parentPath);
            console.log('目录名称:', dirName);
            
            plus.io.resolveLocalFileSystemURL(parentPath, (parentEntry) => {
                console.log('父目录获取成功:', parentEntry);
                parentEntry.getDirectory(dirName, { create: true }, (dirEntry) => {
                    console.log('目录创建成功:', dirEntry);
                    resolve(dirEntry);
                }, (error) => {
                    console.error('目录创建失败:', error);
                    reject(error);
                });
            }, (error) => {
                console.error('父目录获取失败:', error);
                reject(error);
            });
        });
    }

    // 读取目录内容
    readDirectory(path) {
        console.log('读取目录:', path);
        return new Promise((resolve, reject) => {
            console.log('调用plus.io.resolveLocalFileSystemURL');
            plus.io.resolveLocalFileSystemURL(path, (entry) => {
                console.log('目录解析成功:', entry);
                if (entry.isDirectory) {
                    console.log('这是一个目录，创建reader');
                    const reader = entry.createReader();
                    reader.readEntries((entries) => {
                        console.log('目录读取成功，条目数:', entries.length);
                        resolve(entries);
                    }, (error) => {
                        console.error('目录读取失败:', error);
                        reject(error);
                    });
                } else {
                    console.log('这是一个文件');
                    resolve([entry]);
                }
            }, (error) => {
                console.error('目录解析失败:', error);
                console.error('错误详情:', {
                    'code': error.code,
                    'message': error.message
                });
                reject(error);
            });
        });
    }

    // 检查是否为图片文件
    isImageFile(filename) {
        const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp'];
        const ext = filename.toLowerCase().substring(filename.lastIndexOf('.'));
        const isImage = imageExtensions.includes(ext);
        console.log(`检查文件 ${filename} 是否为图片: ${isImage} (扩展名: ${ext})`);
        return isImage;
    }

    // 创建照片对象
    async createPhotoObject(fileEntry, group) {
        console.log('创建照片对象:', fileEntry.name);
        return new Promise((resolve) => {
            fileEntry.file((file) => {
                console.log('文件信息获取成功:', file);
                console.log('文件详细信息:', {
                    'name': file.name,
                    'size': file.size,
                    'lastModified': file.lastModified,
                    'lastModifiedDate': file.lastModifiedDate,
                    'type': file.type
                });
                
                // 处理日期信息
                let timestamp = Date.now(); // 默认使用当前时间
                let date = new Date();
                
                if (file.lastModified && !isNaN(file.lastModified)) {
                    timestamp = file.lastModified;
                    date = new Date(file.lastModified);
                    console.log('使用文件lastModified:', timestamp, date);
                } else if (file.lastModifiedDate) {
                    timestamp = file.lastModifiedDate.getTime();
                    date = new Date(file.lastModifiedDate);
                    console.log('使用文件lastModifiedDate:', timestamp, date);
                } else {
                    console.warn('文件没有有效的修改时间，使用当前时间');
                }
                
                const photoObj = {
                    id: fileEntry.name,
                    filename: fileEntry.name,
                    path: fileEntry.toLocalURL(),
                    filePath: fileEntry.fullPath, // 添加实际文件路径
                    group: group,
                    timestamp: timestamp,
                    date: date,
                    size: file.size
                };
                
                console.log('创建的照片对象:', photoObj);
                resolve(photoObj);
            }, (error) => {
                console.error('获取文件信息失败:', error);
                // 即使获取文件信息失败，也创建一个基本的照片对象
                const photoObj = {
                    id: fileEntry.name,
                    filename: fileEntry.name,
                    path: fileEntry.toLocalURL(),
                    filePath: fileEntry.fullPath, // 添加实际文件路径
                    group: '未分组',
                    timestamp: Date.now(),
                    date: new Date(),
                    size: 0
                };
                console.log('创建的基本照片对象:', photoObj);
                resolve(photoObj);
            });
        });
    }

    // 渲染照片列表
    renderPhotos() {
        console.log('=== 渲染照片列表开始 ===');
        
        // 检查DOM元素是否存在
        const photoGrid = document.getElementById('photo-grid');
        const emptyState = document.getElementById('empty-state');
        
        console.log('DOM元素检查:', {
            'photo-grid存在': !!photoGrid,
            'empty-state存在': !!emptyState,
            'photoGrid类型': photoGrid ? photoGrid.constructor.name : 'null',
            'emptyState类型': emptyState ? emptyState.constructor.name : 'null'
        });
        
        if (!photoGrid) {
            console.error('photo-grid元素不存在！');
            return;
        }
        
        // 应用筛选
        const filteredPhotos = this.getFilteredPhotos();
        console.log('筛选后的照片数量:', filteredPhotos.length);
        
        if (filteredPhotos.length === 0) {
            console.log('没有照片，显示空状态');
            
            // 如果empty-state不存在，重新创建它
            if (!emptyState) {
                console.log('empty-state元素不存在，重新创建');
                const newEmptyState = document.createElement('div');
                newEmptyState.className = 'empty-state';
                newEmptyState.id = 'empty-state';
                newEmptyState.innerHTML = `
                    <div class="empty-icon">📸</div>
                    <div class="empty-text">暂无照片</div>
                    <div class="empty-tip">快去拍照吧！</div>
                `;
                photoGrid.appendChild(newEmptyState);
                console.log('empty-state元素重新创建成功');
            } else {
                console.log('显示现有的empty-state元素');
                emptyState.style.display = 'block';
            }
            
            this.updatePhotoStats(0);
            return;
        }
        
        console.log('隐藏空状态，显示照片网格');
        if (emptyState) {
            emptyState.style.display = 'none';
        }
        
        const photoHTML = filteredPhotos.map(photo => `
            <div class="photo-item" onclick="gallery.openPhotoModal('${photo.id}')" data-photo='${JSON.stringify(photo)}'>
                <img src="${this.getPhotoThumbnail(photo)}" alt="${photo.filename}" 
                     onload="console.log('照片缩略图加载成功:', '${photo.filename}')"
                     onerror="console.error('照片缩略图加载失败:', '${photo.filename}'); this.src=''" />
                <div class="photo-overlay">
                    <div class="photo-info">
                        <span class="photo-time">${this.formatDate(photo.date)}</span>
                        <span class="photo-group">${photo.group}</span>
                    </div>
                </div>
            </div>
        `).join('');
        
        console.log('生成的HTML长度:', photoHTML.length);
        photoGrid.innerHTML = photoHTML;
        this.updatePhotoStats(filteredPhotos.length);
        
        console.log('=== 照片列表渲染完成 ===');
    }

    // 获取照片缩略图
    getPhotoThumbnail(photo) {
        console.log('获取照片缩略图:', photo.filename, '路径:', photo.path, '文件路径:', photo.filePath);
        
        // 优先使用实际文件路径，如果没有则使用URL路径
        const imagePath = photo.filePath || photo.path;
        
        // 如果是真实照片，使用文件路径
        if (imagePath && (imagePath.startsWith('file://') || imagePath.startsWith('/'))) {
            console.log('使用真实照片路径:', imagePath);
            return imagePath;
        }
        
        // 为模拟照片生成彩色占位图
        console.log('使用模拟照片占位图');
        const colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7', '#DDA0DD'];
        const color = colors[Math.floor(Math.random() * colors.length)];
        
        // 生成SVG占位图
        const svg = `
            <svg width="200" height="200" viewBox="0 0 200 200" fill="none" xmlns="http://www.w3.org/2000/svg">
                <rect width="200" height="200" fill="${color}"/>
                <circle cx="100" cy="80" r="20" fill="white" opacity="0.8"/>
                <rect x="60" y="110" width="80" height="60" rx="8" fill="white" opacity="0.8"/>
                <text x="100" y="180" text-anchor="middle" fill="white" font-family="Arial" font-size="12" font-weight="bold">${photo.group}</text>
            </svg>
        `;
        
        const svgBase64 = btoa(unescape(encodeURIComponent(svg)));
        return `data:image/svg+xml;base64,${svgBase64}`;
    }

    // 获取筛选后的照片
    getFilteredPhotos() {
        console.log('筛选照片，当前筛选条件:', this.currentFilter);
        if (this.currentFilter === 'all') {
            console.log('显示所有照片，数量:', this.photos.length);
            return this.photos;
        }
        const filtered = this.photos.filter(photo => photo.group === this.currentFilter);
        console.log(`筛选分组"${this.currentFilter}"的照片，数量:`, filtered.length);
        return filtered;
    }

    // 格式化日期
    formatDate(date) {
        console.log('格式化日期输入:', date, '类型:', typeof date);
        
        try {
            let validDate = null;
            
            // 处理不同类型的日期输入
            if (date instanceof Date && !isNaN(date.getTime())) {
                validDate = date;
                console.log('使用Date对象:', validDate);
            } else if (typeof date === 'number' && !isNaN(date)) {
                validDate = new Date(date);
                console.log('使用时间戳创建Date:', validDate);
            } else if (typeof date === 'string') {
                validDate = new Date(date);
                if (isNaN(validDate.getTime())) {
                    validDate = null;
                }
                console.log('解析日期字符串:', validDate);
            }
            
            if (!validDate || isNaN(validDate.getTime())) {
                console.warn('无效的日期，返回默认值');
                return '未知时间';
            }
            
            const now = new Date();
            const diff = now - validDate;
            const days = Math.floor(diff / (1000 * 60 * 60 * 24));
            
            console.log('日期计算:', {
                'now': now,
                'validDate': validDate,
                'diff': diff,
                'days': days
            });
            
            if (days === 0) {
                return '今天';
            } else if (days === 1) {
                return '昨天';
            } else if (days < 7) {
                return `${days}天前`;
            } else {
                return validDate.toLocaleDateString('zh-CN', {
                    month: 'short',
                    day: 'numeric'
                });
            }
        } catch (error) {
            console.error('日期格式化错误:', error);
            return '时间错误';
        }
    }

    // 更新顶部统计信息
    updateHeaderStats() {
        console.log('=== 更新顶部统计信息 ===');
        
        const headerPhotoCount = document.getElementById('header-photo-count');
        if (!headerPhotoCount) {
            console.error('header-photo-count元素不存在');
            return;
        }
        
        const totalPhotos = this.photos.length;
        headerPhotoCount.textContent = totalPhotos;
        
        console.log('顶部统计信息更新完成，照片总数:', totalPhotos);
        
        // 同步更新统计页面
        if (typeof statsManager !== 'undefined' && statsManager.refresh) {
            console.log('同步更新统计页面');
            statsManager.refresh();
        }
    }

    // 更新照片统计
    updatePhotoStats(count) {
        console.log('更新照片统计，数量:', count);
        
        const totalPhotosElement = document.getElementById('total-photos');
        console.log('total-photos元素检查:', {
            '元素存在': !!totalPhotosElement,
            '元素类型': totalPhotosElement ? totalPhotosElement.constructor.name : 'null'
        });
        
        if (totalPhotosElement) {
            totalPhotosElement.textContent = count;
            console.log('照片统计更新成功');
        } else {
            console.error('total-photos元素不存在！');
        }
        
        // 同时更新顶部统计信息
        this.updateHeaderStats();
    }

    // 刷新相册
    async refresh() {
        console.log('=== 相册刷新开始 ===');
        
        if (this.isLoading) {
            console.log('相册正在加载中，跳过刷新');
            return;
        }
        
        this.isLoading = true;
        console.log('设置加载状态为true');
        
        try {
            // 重新加载照片
            await this.loadRealPhotos();
            
            // 更新分组筛选下拉框
            this.updateGroupFilterDropdown();
            
            // 重新渲染照片
            this.renderPhotos();
            
            // 更新顶部统计信息
            this.updateHeaderStats();
            
            console.log('相册刷新完成');
            
        } catch (error) {
            console.error('相册刷新失败:', error);
            showToast('相册刷新失败: ' + error.message, 'error');
        } finally {
            this.isLoading = false;
            console.log('设置加载状态为false');
        }
    }

    // 筛选照片
    filterPhotos(filterValue) {
        console.log('=== 筛选照片开始 ===');
        console.log('筛选值:', filterValue);
        this.currentFilter = filterValue;
        this.renderPhotos();
        console.log('=== 筛选照片结束 ===');
    }

    // 打开照片预览模态框
    openPhotoModal(photoId) {
        console.log('=== 打开照片预览模态框 ===');
        console.log('照片ID:', photoId);
        
        // 获取照片数据
        const photoItem = document.querySelector(`[data-photo*="${photoId}"]`);
        console.log('照片元素检查:', {
            '元素存在': !!photoItem,
            '元素类型': photoItem ? photoItem.constructor.name : 'null'
        });
        
        if (!photoItem) {
            console.error('未找到照片数据:', photoId);
            return;
        }
        
        const photoData = JSON.parse(photoItem.getAttribute('data-photo'));
        console.log('照片数据:', photoData);
        console.log('照片日期信息:', {
            'date类型': typeof photoData.date,
            'date值': photoData.date,
            'timestamp类型': typeof photoData.timestamp,
            'timestamp值': photoData.timestamp
        });
        
        // 填充模态框数据
        const modalPhoto = document.getElementById('modal-photo');
        const modalFilename = document.getElementById('modal-filename');
        const modalTime = document.getElementById('modal-time');
        const modalGroup = document.getElementById('modal-group');
        
        console.log('模态框元素检查:', {
            'modal-photo存在': !!modalPhoto,
            'modal-filename存在': !!modalFilename,
            'modal-time存在': !!modalTime,
            'modal-group存在': !!modalGroup
        });
        
        if (modalPhoto) {
            // 优先使用实际文件路径，如果没有则使用URL路径
            const imagePath = photoData.filePath || photoData.path;
            console.log('设置模态框照片路径:', imagePath);
            console.log('照片数据详情:', {
                'path': photoData.path,
                'filePath': photoData.filePath,
                'filename': photoData.filename,
                'group': photoData.group
            });
            
            // 设置图片源
            modalPhoto.src = imagePath;
            
            // 添加图片加载事件监听
            modalPhoto.onload = () => {
                console.log('模态框照片加载成功:', imagePath);
            };
            
            modalPhoto.onerror = (error) => {
                console.error('模态框照片加载失败:', imagePath, error);
                // 如果加载失败，尝试使用备用路径
                if (photoData.path && photoData.path !== imagePath) {
                    console.log('尝试使用备用路径:', photoData.path);
                    modalPhoto.src = photoData.path;
                }
            };
        }
        if (modalFilename) modalFilename.textContent = photoData.filename;
        
        // 处理日期显示
        if (modalTime) {
            let displayTime = '未知时间';
            
            try {
                // 尝试多种方式获取有效日期
                let validDate = null;
                
                if (photoData.date instanceof Date && !isNaN(photoData.date.getTime())) {
                    // 如果date是有效的Date对象
                    validDate = photoData.date;
                    console.log('使用photoData.date:', validDate);
                } else if (photoData.timestamp && !isNaN(photoData.timestamp)) {
                    // 如果timestamp有效，创建Date对象
                    validDate = new Date(photoData.timestamp);
                    console.log('使用photoData.timestamp创建Date:', validDate);
                } else if (photoData.date && typeof photoData.date === 'string') {
                    // 如果date是字符串，尝试解析
                    validDate = new Date(photoData.date);
                    if (isNaN(validDate.getTime())) {
                        validDate = null;
                    }
                    console.log('解析photoData.date字符串:', validDate);
                }
                
                if (validDate && !isNaN(validDate.getTime())) {
                    displayTime = validDate.toLocaleString('zh-CN', {
                        year: 'numeric',
                        month: '2-digit',
                        day: '2-digit',
                        hour: '2-digit',
                        minute: '2-digit',
                        second: '2-digit'
                    });
                    console.log('格式化后的时间:', displayTime);
                } else {
                    console.warn('无法获取有效日期，使用默认值');
                    displayTime = '拍摄时间未知';
                }
            } catch (error) {
                console.error('日期处理错误:', error);
                displayTime = '时间格式错误';
            }
            
            modalTime.textContent = displayTime;
        }
        
        if (modalGroup) modalGroup.textContent = photoData.group;
        
        // 显示模态框
        const modal = document.getElementById('photo-modal');
        console.log('模态框元素检查:', {
            'modal存在': !!modal,
            'modal类型': modal ? modal.constructor.name : 'null'
        });
        
        if (modal) {
            modal.style.display = 'flex';
            // 保存当前照片ID用于删除操作
            modal.setAttribute('data-current-photo-id', photoId);
            console.log('模态框显示成功');
        } else {
            console.error('photo-modal元素不存在！');
        }
    }

    // 关闭照片预览模态框
    closePhotoModal() {
        console.log('=== 关闭照片预览模态框 ===');
        const modal = document.getElementById('photo-modal');
        console.log('模态框元素检查:', {
            'modal存在': !!modal,
            'modal类型': modal ? modal.constructor.name : 'null'
        });
        
        if (modal) {
            modal.style.display = 'none';
            modal.removeAttribute('data-current-photo-id');
            console.log('模态框关闭成功');
        } else {
            console.error('photo-modal元素不存在！');
        }
    }

    // 删除照片
    async deletePhoto() {
        console.log('=== 删除照片开始 ===');
        const modal = document.getElementById('photo-modal');
        const photoId = modal ? modal.getAttribute('data-current-photo-id') : null;
        
        console.log('删除照片信息:', {
            'modal存在': !!modal,
            'photoId': photoId
        });
        
        if (!photoId) {
            console.error('未找到要删除的照片ID');
            return;
        }
        
        // 找到要删除的照片对象
        const photoToDelete = this.photos.find(photo => photo.id === photoId);
        if (!photoToDelete) {
            console.error('未找到要删除的照片对象:', photoId);
            showToast('照片不存在', 'error');
            return;
        }
        
        console.log('要删除的照片:', photoToDelete);
        
        // 显示删除确认对话框
        if (typeof plus !== 'undefined' && plus.nativeUI) {
            plus.nativeUI.confirm(
                `确定要删除照片 "${photoToDelete.filename}" 吗？\n\n此操作不可撤销。`,
                (e) => {
                    if (e.index === 0) {
                        // 用户点击了确定
                        this.performDelete(photoToDelete, photoId);
                    } else {
                        // 用户点击了取消
                        console.log('用户取消删除');
                    }
                },
                '删除确认',
                ['确定删除', '取消']
            );
        } else {
            // 如果没有plus环境，直接删除
            this.performDelete(photoToDelete, photoId);
        }
    }

    // 执行删除操作
    async performDelete(photoToDelete, photoId) {
        console.log('=== 执行删除操作 ===');
        
        try {
            // 显示删除中提示
            showToast('正在删除照片...', 'info');
            
            // 先删除文件系统中的文件
            await this.deleteFileFromSystem(photoToDelete);
            
            // 从数组中移除照片
            this.photos = this.photos.filter(photo => photo.id !== photoId);
            console.log('从数组中移除照片成功，剩余照片数:', this.photos.length);
            
            // 关闭模态框
            this.closePhotoModal();
            
            // 重新渲染照片列表
            this.renderPhotos();
            
            // 更新顶部统计信息
            this.updateHeaderStats();
            
            showToast('照片删除成功', 'success');
            
        } catch (error) {
            console.error('删除照片失败:', error);
            showToast('删除照片失败: ' + error.message, 'error');
        }
    }

    // 从文件系统删除文件
    async deleteFileFromSystem(photo) {
        console.log('=== 从文件系统删除文件 ===');
        console.log('照片信息:', photo);
        
        return new Promise((resolve, reject) => {
            // 构建文件路径
            const filePath = photo.path;
            console.log('原始文件路径:', filePath);
            
            // 处理不同格式的文件路径
            let relativePath = filePath;
            
            if (filePath.startsWith('file://')) {
                // 从file://路径中提取相对路径
                const pathParts = filePath.split('/');
                const docIndex = pathParts.indexOf('doc');
                if (docIndex !== -1) {
                    relativePath = '_doc/' + pathParts.slice(docIndex + 1).join('/');
                } else {
                    // 如果找不到doc目录，尝试其他方式
                    const photoFilerIndex = pathParts.indexOf('PhotoFiler');
                    if (photoFilerIndex !== -1) {
                        relativePath = '_doc/PhotoFiler/' + pathParts.slice(photoFilerIndex + 1).join('/');
                    }
                }
            } else if (filePath.startsWith('_doc/')) {
                // 已经是相对路径
                relativePath = filePath;
            } else {
                // 其他格式，尝试构建相对路径
                relativePath = '_doc/PhotoFiler/' + photo.filename;
            }
            
            console.log('处理后的相对路径:', relativePath);
            
            // 使用resolveLocalFileSystemURL获取文件entry
            plus.io.resolveLocalFileSystemURL(relativePath, (entry) => {
                console.log('文件entry获取成功:', entry);
                console.log('文件entry信息:', {
                    'name': entry.name,
                    'fullPath': entry.fullPath,
                    'isFile': entry.isFile,
                    'isDirectory': entry.isDirectory
                });
                
                // 删除文件
                entry.remove(() => {
                    console.log('文件删除成功:', relativePath);
                    resolve();
                }, (error) => {
                    console.error('文件删除失败:', error);
                    console.error('删除错误详情:', {
                        'code': error.code,
                        'message': error.message
                    });
                    reject(new Error('文件删除失败: ' + error.message));
                });
                
            }, (error) => {
                console.error('文件路径解析失败:', error);
                console.error('路径解析错误详情:', {
                    'code': error.code,
                    'message': error.message,
                    '尝试的路径': relativePath
                });
                
                // 尝试使用文件名直接删除
                const fallbackPath = '_doc/PhotoFiler/' + photo.filename;
                console.log('尝试备用路径:', fallbackPath);
                
                plus.io.resolveLocalFileSystemURL(fallbackPath, (entry) => {
                    console.log('备用路径文件entry获取成功:', entry);
                    
                    entry.remove(() => {
                        console.log('使用备用路径删除成功:', fallbackPath);
                        resolve();
                    }, (fallbackError) => {
                        console.error('备用路径删除也失败:', fallbackError);
                        reject(new Error('文件删除失败: ' + fallbackError.message));
                    });
                    
                }, (fallbackError) => {
                    console.error('备用路径解析也失败:', fallbackError);
                    reject(new Error('无法找到要删除的文件: ' + photo.filename));
                });
            });
        });
    }

    // 分享照片
    sharePhoto() {
        console.log('分享照片');
        
        // 检查分享模块是否可用
        if (typeof photoShare === 'undefined') {
            showToast('分享模块未初始化', 'error');
            return;
        }

        // 获取当前模态框中的照片信息
        const modalPhoto = document.getElementById('modal-photo');
        const modalFilename = document.getElementById('modal-filename');
        const modalTime = document.getElementById('modal-time');
        const modalGroup = document.getElementById('modal-group');
        
        if (!modalPhoto || !modalPhoto.src) {
            showToast('没有可分享的照片', 'error');
            return;
        }

        // 构造照片对象
        const photo = {
            path: modalPhoto.src,
            filename: modalFilename ? modalFilename.textContent : '未知文件',
            timestamp: modalTime ? new Date(modalTime.textContent).getTime() : Date.now(),
            group: modalGroup ? modalGroup.textContent : '未分组'
        };

        console.log('准备分享照片:', photo);
        
        // 设置当前照片并显示分享选项
        photoShare.setCurrentPhoto(photo);
        photoShare.showShareOptions();
    }

    // 更新分组筛选选项
    updateGroupFilterOptions(newGroup) {
        console.log('=== 更新分组筛选选项 ===');
        console.log('新分组:', newGroup);
        
        const groupFilter = document.getElementById('group-filter');
        if (!groupFilter) {
            console.error('group-filter元素不存在');
            return;
        }
        
        // 检查是否已存在该分组选项
        let groupExists = false;
        for (let i = 0; i < groupFilter.options.length; i++) {
            if (groupFilter.options[i].value === newGroup) {
                groupExists = true;
                break;
            }
        }
        
        if (!groupExists) {
            console.log('添加新分组选项:', newGroup);
            const option = document.createElement('option');
            option.value = newGroup;
            option.textContent = newGroup;
            groupFilter.appendChild(option);
        } else {
            console.log('分组选项已存在:', newGroup);
        }
    }

    // 获取所有可用分组
    getAvailableGroups() {
        console.log('=== 获取所有可用分组 ===');
        
        const groups = new Set();
        
        // 从照片数据中提取分组
        this.photos.forEach(photo => {
            if (photo.group && photo.group !== '未分组' && !photo.group.includes('.')) {
                // 确保分组名称不包含文件扩展名
                groups.add(photo.group);
            }
        });
        
        // 从本地存储获取当前分组
        if (typeof plus !== 'undefined' && plus.storage) {
            try {
                const currentGroup = plus.storage.getItem('current_group');
                if (currentGroup && currentGroup.trim() !== '') {
                    groups.add(currentGroup.trim());
                }
            } catch (error) {
                console.error('读取本地存储失败:', error);
            }
        }
        
        const groupArray = Array.from(groups).sort();
        console.log('可用分组:', groupArray);
        return groupArray;
    }

    // 更新分组筛选下拉框
    updateGroupFilterDropdown() {
        console.log('=== 更新分组筛选下拉框 ===');
        
        const groupFilter = document.getElementById('group-filter');
        if (!groupFilter) {
            console.error('group-filter元素不存在');
            return;
        }
        
        // 保存当前选中的值
        const currentValue = groupFilter.value;
        
        // 清空现有选项（保留"所有分组"）
        while (groupFilter.options.length > 1) {
            groupFilter.remove(1);
        }
        
        // 获取所有可用分组
        const groups = this.getAvailableGroups();
        
        // 添加分组选项
        groups.forEach(group => {
            const option = document.createElement('option');
            option.value = group;
            option.textContent = group;
            groupFilter.appendChild(option);
        });
        
        // 恢复选中值
        if (currentValue && (currentValue === 'all' || groups.includes(currentValue))) {
            groupFilter.value = currentValue;
        } else {
            groupFilter.value = 'all';
        }
        
        console.log('分组筛选下拉框更新完成，选项数量:', groupFilter.options.length);
    }
}

// 创建全局相册实例
console.log('创建全局相册实例');
const gallery = new PhotoGallery();

// 页面加载完成后初始化相册
document.addEventListener('DOMContentLoaded', function() {
    console.log('DOM加载完成，初始化相册');
    gallery.init();
});

// 导出全局函数供HTML调用
console.log('导出全局函数');
window.refreshGallery = () => {
    console.log('=== 调用全局refreshGallery函数 ===');
    console.log('当前时间:', new Date().toLocaleString());
    
    if (typeof gallery !== 'undefined') {
        console.log('gallery对象存在，调用refresh方法');
        gallery.refresh().then(() => {
            console.log('相册刷新完成');
        }).catch((error) => {
            console.error('相册刷新失败:', error);
        });
    } else {
        console.error('gallery对象不存在！');
        showToast('相册模块未初始化', 'error');
    }
};
window.filterPhotos = () => {
    console.log('调用全局filterPhotos函数');
    const filterValue = document.getElementById('group-filter').value;
    console.log('筛选值:', filterValue);
    gallery.filterPhotos(filterValue);
};
window.openPhotoModal = (photoId) => {
    console.log('调用全局openPhotoModal函数，照片ID:', photoId);
    gallery.openPhotoModal(photoId);
};
window.closePhotoModal = () => {
    console.log('调用全局closePhotoModal函数');
    gallery.closePhotoModal();
};
window.deletePhoto = () => {
    console.log('调用全局deletePhoto函数');
    gallery.deletePhoto();
};
window.sharePhoto = () => {
    console.log('调用全局sharePhoto函数');
    gallery.sharePhoto();
};

// 批量分享选中的照片
window.shareSelectedPhotos = () => {
    console.log('调用全局shareSelectedPhotos函数');
    
    // 检查分享模块是否可用
    if (typeof photoShare === 'undefined') {
        showToast('分享模块未初始化', 'error');
        return;
    }

    // 获取当前筛选的照片
    const filteredPhotos = gallery.getFilteredPhotos();
    
    if (filteredPhotos.length === 0) {
        showToast('没有可分享的照片', 'error');
        return;
    }

    // 显示选择对话框
    showPhotoSelectionDialog(filteredPhotos);
};

// 显示照片选择对话框
function showPhotoSelectionDialog(photos) {
    const dialog = document.createElement('div');
    dialog.className = 'photo-selection-overlay';
    dialog.innerHTML = `
        <div class="photo-selection-dialog">
            <div class="dialog-header">
                <h4>选择要分享的照片</h4>
                <button class="close-btn" onclick="this.parentElement.parentElement.parentElement.remove()">×</button>
            </div>
            <div class="dialog-content">
                <div class="selection-controls">
                    <button class="select-all-btn" onclick="toggleSelectAll()">全选</button>
                    <button class="select-none-btn" onclick="toggleSelectNone()">取消全选</button>
                </div>
                <div class="photo-selection-grid">
                    ${photos.map((photo, index) => `
                        <div class="photo-selection-item" data-index="${index}">
                            <input type="checkbox" id="photo-${index}" class="photo-checkbox" checked>
                            <label for="photo-${index}" class="photo-label">
                                <img src="${gallery.getPhotoThumbnail(photo)}" alt="${photo.filename}" class="photo-thumb"
                                     onload="console.log('选择对话框照片加载成功:', '${photo.filename}')"
                                     onerror="console.error('选择对话框照片加载失败:', '${photo.filename}'); this.src=''" />
                                <div class="photo-info">
                                    <div class="photo-name">${photo.filename}</div>
                                    <div class="photo-group">${photo.group}</div>
                                </div>
                            </label>
                        </div>
                    `).join('')}
                </div>
            </div>
            <div class="dialog-footer">
                <button class="cancel-btn" onclick="this.parentElement.parentElement.remove()">取消</button>
                <button class="share-btn" onclick="shareSelectedPhotosFromDialog()">分享选中</button>
            </div>
        </div>
    `;

    document.body.appendChild(dialog);
    
    // 添加样式
    if (!document.getElementById('photo-selection-styles')) {
        const style = document.createElement('style');
        style.id = 'photo-selection-styles';
        style.textContent = `
            .photo-selection-overlay {
                position: fixed;
                top: 0;
                left: 0;
                right: 0;
                bottom: 0;
                background: rgba(0, 0, 0, 0.5);
                z-index: 10000;
                display: flex;
                align-items: center;
                justify-content: center;
                padding: 20px;
            }
            .photo-selection-dialog {
                width: 100%;
                max-width: 500px;
                background: white;
                border-radius: 12px;
                max-height: 80vh;
                overflow: hidden;
                display: flex;
                flex-direction: column;
            }
            .dialog-header {
                padding: 16px;
                border-bottom: 1px solid #eee;
                display: flex;
                justify-content: space-between;
                align-items: center;
            }
            .dialog-header h4 {
                margin: 0;
                font-size: 16px;
                font-weight: 600;
            }
            .close-btn {
                background: none;
                border: none;
                font-size: 20px;
                cursor: pointer;
                padding: 0;
                width: 24px;
                height: 24px;
                display: flex;
                align-items: center;
                justify-content: center;
            }
            .dialog-content {
                flex: 1;
                overflow-y: auto;
                padding: 16px;
            }
            .selection-controls {
                display: flex;
                gap: 8px;
                margin-bottom: 16px;
            }
            .select-all-btn, .select-none-btn {
                padding: 8px 16px;
                border: 1px solid #ddd;
                background: white;
                border-radius: 6px;
                cursor: pointer;
                font-size: 14px;
            }
            .select-all-btn:active, .select-none-btn:active {
                background: #f5f5f5;
            }
            .photo-selection-grid {
                display: grid;
                grid-template-columns: repeat(auto-fill, minmax(120px, 1fr));
                gap: 12px;
            }
            .photo-selection-item {
                position: relative;
                border: 1px solid #eee;
                border-radius: 8px;
                overflow: hidden;
            }
            .photo-checkbox {
                position: absolute;
                top: 8px;
                left: 8px;
                z-index: 2;
                width: 16px;
                height: 16px;
            }
            .photo-label {
                display: block;
                cursor: pointer;
            }
            .photo-thumb {
                width: 100%;
                height: 80px;
                object-fit: cover;
            }
            .photo-info {
                padding: 8px;
            }
            .photo-name {
                font-size: 12px;
                font-weight: 500;
                margin-bottom: 2px;
                overflow: hidden;
                text-overflow: ellipsis;
                white-space: nowrap;
            }
            .photo-group {
                font-size: 10px;
                color: #666;
            }
            .dialog-footer {
                padding: 16px;
                border-top: 1px solid #eee;
                display: flex;
                gap: 12px;
            }
            .cancel-btn, .share-btn {
                flex: 1;
                padding: 12px;
                border: none;
                border-radius: 8px;
                font-size: 16px;
                cursor: pointer;
            }
            .cancel-btn {
                background: #f5f5f5;
                color: #666;
            }
            .share-btn {
                background: #007aff;
                color: white;
            }
            .cancel-btn:active {
                background: #e5e5e5;
            }
            .share-btn:active {
                background: #0056cc;
            }
        `;
        document.head.appendChild(style);
    }
}

// 全选/取消全选功能
window.toggleSelectAll = () => {
    const checkboxes = document.querySelectorAll('.photo-checkbox');
    const allChecked = Array.from(checkboxes).every(cb => cb.checked);
    checkboxes.forEach(cb => cb.checked = !allChecked);
};

window.toggleSelectNone = () => {
    const checkboxes = document.querySelectorAll('.photo-checkbox');
    checkboxes.forEach(cb => cb.checked = false);
};

// 从对话框分享选中的照片
window.shareSelectedPhotosFromDialog = () => {
    const checkboxes = document.querySelectorAll('.photo-checkbox:checked');
    const selectedIndices = Array.from(checkboxes).map(cb => parseInt(cb.id.replace('photo-', '')));
    
    if (selectedIndices.length === 0) {
        showToast('请选择要分享的照片', 'error');
        return;
    }

    // 获取当前筛选的照片
    const filteredPhotos = gallery.getFilteredPhotos();
    const selectedPhotos = selectedIndices.map(index => filteredPhotos[index]);

    console.log('选中的照片:', selectedPhotos);

    // 关闭对话框
    const dialog = document.querySelector('.photo-selection-overlay');
    if (dialog) {
        dialog.remove();
    }

    // 分享选中的照片
    if (typeof photoShare !== 'undefined') {
        photoShare.shareMultiplePhotos(selectedPhotos);
    } else {
        showToast('分享模块未初始化', 'error');
    }
};

// ======= 批量导出全部照片到公共目录 =======
function exportAllPhotosToPublicDir() {
    if (typeof plus === 'undefined' || !plus.io) {
        alert('当前环境不支持文件导出，请在App中使用');
        return;
    }
    const appBase = '_doc/PhotoFiler/';
    plus.nativeUI.showWaiting('正在导出照片...');
    plus.io.resolveLocalFileSystemURL(appBase, function(dirEntry) {
        const reader = dirEntry.createReader();
        reader.readEntries(function(entries) {
            let allPhotoTasks = [];
            entries.forEach(function(entry) {
                if (entry.isDirectory) {
                    // 分组，收集每张图片的Promise
                    allPhotoTasks.push(
                        new Promise((resolve) => {
                            entry.createReader().readEntries(function(files) {
                                let fileTasks = files.filter(f => f.isFile).map(f => copyFileToPublic(f, entry.name));
                                Promise.allSettled(fileTasks).then(resolve);
                            }, resolve);
                        })
                    );
                } else if (entry.isFile) {
                    // 未分组照片
                    allPhotoTasks.push(copyFileToPublic(entry, '未分组'));
                }
            });
            // 展开所有分组的图片Promise
            Promise.allSettled(allPhotoTasks).then((groupResults) => {
                // groupResults 里每个是分组的Promise.allSettled结果或单张图片的Promise
                // 需要把所有分组的结果展开成单张图片的结果
                let photoResults = [];
                groupResults.forEach(r => {
                    if (Array.isArray(r.value)) {
                        // 分组
                        photoResults = photoResults.concat(r.value);
                    } else {
                        // 单张
                        photoResults.push(r);
                    }
                });
                let finished = photoResults.filter(r => r.status === 'fulfilled').length;
                let failed = photoResults.length - finished;
                plus.nativeUI.closeWaiting();
                plus.nativeUI.toast('导出完成：成功' + finished + '，失败' + failed);
            });
        }, function(e) {
            plus.nativeUI.closeWaiting();
            plus.nativeUI.toast('读取目录失败：' + e.message);
        });
    }, function(e) {
        plus.nativeUI.closeWaiting();
        plus.nativeUI.toast('未找到应用相册目录');
    });
}
function copyFileToPublic(fileEntry, groupName) {
    // Android 13+ 需申请图片/视频访问权限
    if (plus.android) {
        var main = plus.android.runtimeMainActivity();
        var PackageManager = plus.android.importClass("android.content.pm.PackageManager");
        var permission = "android.permission.READ_MEDIA_IMAGES"; // Android 13+ 新权限
        if (main.checkSelfPermission(permission) !== PackageManager.PERMISSION_GRANTED) {
            main.requestPermissions([permission], 0);
        }
    }
    return new Promise((resolve, reject) => {
        plus.gallery.save(fileEntry.fullPath, function() {
            console.log('[导出] 图片已保存到系统相册:', fileEntry.fullPath);
            resolve();
        }, function(e) {
            console.error('[导出] 保存到系统相册失败:', JSON.stringify(e), e && e.message, e && e.code);
            resolve();
        });
    });
}

// ======= 导出全部分组为zip并分享 =======
function exportAllGroupsAsZip() {
    if (typeof plus === 'undefined' || !plus.zip) {
        alert('当前环境不支持压缩，请在App中使用');
        return;
    }
    const sourceDir = '_doc/PhotoFiler/';
    const exportDir = '_doc/PhotoFilerExport/';
    const zipPath = exportDir + 'all_groups.zip';
    plus.nativeUI.showWaiting('正在压缩全部分组...');
    // 先确保导出目录存在
    plus.io.resolveLocalFileSystemURL(exportDir, function() {
        doZip();
    }, function() {
        // 不存在则创建
        plus.io.resolveLocalFileSystemURL('_doc/', function(root) {
            root.getDirectory('PhotoFilerExport', {create: true}, function() {
                doZip();
            }, function(e) {
                plus.nativeUI.closeWaiting();
                plus.nativeUI.toast('创建导出目录失败: ' + e.message);
            });
        });
    });
    function doZip() {
        plus.zip.compress(sourceDir, zipPath, function() {
            plus.nativeUI.closeWaiting();
            plus.nativeUI.toast('压缩成功！');
            shareZipFile(zipPath);
        }, function(e) {
            plus.nativeUI.closeWaiting();
            plus.nativeUI.toast('压缩失败: ' + e.message);
        });
    }
}

function shareZipFile(zipPath) {
    plus.nativeUI.confirm(
        '微信等应用不支持直接分享压缩包文件。\n请在文件管理器中找到压缩包并用微信文件助手发送。\n是否现在打开文件位置？',
        function(e) {
            if (e.index === 0) {
                // 打开文件目录
                plus.io.resolveLocalFileSystemURL(zipPath, function(entry) {
                    plus.runtime.openFile(entry.fullPath);
                }, function(err) {
                    plus.nativeUI.toast('无法打开文件: ' + err.message);
                });
            }
        },
        '提示',
        ['打开文件位置', '取消']
    );
} 